package gradle.common.core.utils;


import cn.hutool.core.util.StrUtil;
import com.google.common.base.CaseFormat;
import gradle.common.core.annotation.SortPre;
import gradle.common.core.enums.SortEnum;
import gradle.common.core.mode.page.QuerySort;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

/**
 * 代码层级排序拼装工具类
 *
 * @author 1141193930@qq.com
 */
public class SortUtil {

    /**
     * 获取排序字符串
     *
     * @param sort           排序字段
     * @param defaultSortStr 默认排序str
     * @param defaultPre     默认排序字段前缀
     * @param clazz          接口Vo类
     * @return 排序String
     */
    public static String getSortStrHaveDefault(List<QuerySort> sort, String defaultSortStr, String defaultPre, Class<?> clazz) {
        String sortStr = getSortStr(sort, defaultSortStr, defaultPre, clazz);
        // 返回的排序字段与默认排序字段不相等时，拼接默认排序字段
        if (!Objects.equals(defaultSortStr, sortStr)) {
            sortStr = sortStr + StrUtil.COMMA + defaultSortStr;
        }
        return sortStr;
    }


    /**
     * 获取排序字符串
     *
     * @param sort           排序字段
     * @param defaultSortStr 默认排序str
     * @param defaultPre     默认排序字段前缀，例如排序字段来自于三张表，共十个排序字段，7个排序字段所在的表为运单则默认排序字段为dw.，其余三个字段通过注解@SortPre.pre = ''单独指定
     * @param tClass         sql返回的Vo
     * @return 排序String
     */
    public static String getSortStr(List<QuerySort> sort, String defaultSortStr, String defaultPre, Class<?> tClass) {
        // 如果排序列表为空，返回默认排序字符串
        if (CollectionUtils.isEmpty(sort)) {
            return defaultSortStr;
        }

        // 获取当前类及所有父类的字段（排除Object类）
        List<Field> allFields = getAllFields(tClass);

        StringBuilder builder = new StringBuilder();
        for (QuerySort querySort : sort) {
            // 检查字段是否存在于类层次结构中
            Field matchedField = findFieldInHierarchy(allFields, querySort.getField());
            if (matchedField == null) {
                continue; // 字段不存在，跳过
            }

            // 处理字段注解和排序逻辑
            defaultPre = processFieldAnnotations(matchedField, querySort, defaultPre);

            // 构建排序字符串
            buildSortString(builder, querySort, defaultPre);
        }

        return StringUtils.isNotBlank(builder) ?
                builder.substring(0, builder.length() - 1) : // 去除末尾逗号
                defaultSortStr;
    }

    /**
     * 获取排序字符串
     *
     * @param sort           排序字段
     * @param defaultSortStr 默认排序str
     * @param tClass         sql返回的Vo
     * @return 排序String
     */
    public static String getSortStr(List<QuerySort> sort, String defaultSortStr, Class<?> tClass) {
        return getSortStr(sort, defaultSortStr, "", tClass);
    }


    /**
     * 获取类及其所有父类的字段（排除Object类）
     */
    private static List<Field> getAllFields(Class<?> clazz) {
        List<Field> fields = new ArrayList<>();
        Class<?> currentClass = clazz;

        // 遍历类层次结构，直到Object类为止[1,2](@ref)
        while (currentClass != null && currentClass != Object.class) {
            // 获取当前类的所有声明字段[5](@ref)
            Field[] declaredFields = currentClass.getDeclaredFields();
            Collections.addAll(fields, declaredFields);

            // 移动到父类[1,2](@ref)
            currentClass = currentClass.getSuperclass();
        }
        return fields;
    }

    /**
     * 在字段列表中查找匹配的字段
     */
    private static Field findFieldInHierarchy(List<Field> allFields, String fieldName) {
        return allFields.stream()
                .filter(field -> field.getName().equals(fieldName))
                .findFirst()
                .orElse(null);
    }

    /**
     * 处理字段的注解配置
     */
    private static String processFieldAnnotations(Field field, QuerySort querySort, String defaultPre) {
        SortPre sortPre = field.getAnnotation(SortPre.class);
        if (sortPre != null) {
            // 处理前缀配置
            String pre = sortPre.pre();
            if (StringUtils.isNotBlank(pre)) {
                // 注意：这里需要处理defaultPre的传递
                defaultPre = pre;
            }

            // 处理字段重命名
            String value = sortPre.value();
            if (StringUtils.isNotBlank(value)) {
                querySort.setField(value);
            }
        }
        return defaultPre;
    }

    /**
     * 构建排序字符串片段
     */
    private static void buildSortString(StringBuilder builder, QuerySort querySort, String defaultPre) {
        // 转换为下划线命名[3](@ref)
        String fieldName = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, querySort.getField());

        builder.append(defaultPre)
                .append(fieldName)
                .append(" ")
                .append(querySort.getIsAsc().equals(SortEnum.ASC.getCode()) ? "asc" : "desc")
                .append(",");
    }


}
